export const 图片元素减后台 = (str, 后台基础路径) => {
    if (!str) return
    const regex = new RegExp(`(?<=<img [^>]*src=['"])(${后台基础路径})+(?=[^'"]+[^>]*>)`, "g")
    str = str.replace(regex, "")
    return str
}

export const 图片元素加后台 = (str, 后台基础路径) => {
    if (!str) return
    str = str.replace(/<img [^>]*src=['"]([^'"]+)[^>]*>/g, (match, capture) => {
        // console.log('capture: ', capture);
        const 新 = 予图片路径(capture, 后台基础路径)
        // console.log('新: ', 新);
        return match.replace(capture, 新)
    })
    return str
}

export const 予图片路径 = (url, 后台基础路径) => {
    if (url && url.slice(0, 4) !== "http") {
        if (后台基础路径 === "/") {
            return url
        }
        if (url.slice(0, 1) === "/") {
            return 后台基础路径 + url
        }
        return 后台基础路径 + "/" + url
    } else {
        return url
    }
}

export function cs() {
    console.log("cs ing🙋‍")
}

export const isArray = value => Object.prototype.toString.call(value) === "[object Array]"


export function 格式化日期(date, format) {
    const year = date.getFullYear()
    const month = String(date.getMonth() + 1).padStart(2, "0")
    const day = String(date.getDate()).padStart(2, "0")
    const hours = String(date.getHours()).padStart(2, "0")
    const minutes = String(date.getMinutes()).padStart(2, "0")
    const seconds = String(date.getSeconds()).padStart(2, "0")
    // console.log('format: ', format);
    return format
        .replace("yyyy", year)
        .replace("MM", month)
        .replace("dd", day)
        .replace("HH", hours)
        .replace("mm", minutes)
        .replace("ss", seconds)
}

export function 获取数组中对象最大值(arr, 字段 = "id") {
    let max = 0
    if (arr.length != 0) {
        max = Math.max(...arr.map(item => parseInt(item[字段])))
    }
    return max
}

export function 深拷贝_全(target, map = new WeakMap()) {
    // 如果 target 是基本类型或者为 null，直接返回
    if (typeof target !== "object" || target === null) {
        return target
    }

    // 检查是否已经拷贝过该对象，避免循环引用
    if (map.has(target)) {
        return map.get(target)
    }

    let clone
    if (Array.isArray(target)) {
        // 如果是数组，创建一个新数组
        clone = []
        map.set(target, clone)
        // 递归拷贝数组元素
        target.forEach((item, index) => {
            clone[index] = 深拷贝_全(item, map)
        })
    } else if (target instanceof Date) {
        // 如果是日期对象，创建一个新的日期对象
        clone = new Date(target.getTime())
        map.set(target, clone)
    } else if (target instanceof RegExp) {
        // 如果是正则对象，创建一个新的正则对象
        clone = new RegExp(target)
        map.set(target, clone)
    } else {
        // 如果是普通对象，创建一个新对象
        clone = {}
        map.set(target, clone)
        // 递归拷贝对象属性
        for (const key in target) {
            if (target.hasOwnProperty(key)) {
                clone[key] = 深拷贝_全(target[key], map)
            }
        }
    }
    return clone
}

export function 深拷贝(obj) {
    const obj1 = JSON.parse(JSON.stringify(obj))
    return obj1
}

export function 正则匹配(str, 表达式) {
    // const 表达式 = `(\\d+)${替换组[0]}`
    // console.log('表达式: ', 表达式);
    const regexp = new RegExp(表达式, "g")
    let match = regexp.test(str)
    return match
}

export function 数字末尾字符替换(str, 替换组 = []) {
    const 表达式 = `(\\d+)${替换组[0]}`
    // console.log('表达式: ', 表达式);

    const numberRegex = new RegExp(表达式, "g")
    let result = str
    let match
    while ((match = numberRegex.exec(result)) !== null) {
        let 原数字 = match[1]
        console.log("原数字: ", 原数字)
        result = result.replace(match[0], 原数字 + 替换组[1])
    }
    return result
}

